import Cookies from "js-cookie";
import { useUserStoreHook } from "@/store/modules/user";
import { storageLocal, isString, isIncludeAllChildren } from "@pureadmin/utils";

export interface DataInfo<T> {
  /** token */
  accessToken: string;
  /** `accessToken`的过期时间（时间戳） */
  expires: T;
  /** 用于调用刷新accessToken的接口时所需的token */
  refreshToken: string;
  /** 用户ID */
  id?: number;
  /** 头像 */
  avatar?: string;
  /** 用户名 */
  username?: string;
  /** 昵称 */
  nickname?: string;
  /** 当前登录用户的角色 */
  roles?: Array<string>;
  /** 当前登录用户的按钮级别权限 */
  permissions?: Array<string>;
}

export const userKey = "user-info";
export const TokenKey = "authorized-token";
/**
 * 通过`multiple-tabs`是否在`cookie`中，判断用户是否已经登录系统，
 * 从而支持多标签页打开已经登录的系统后无需再登录。
 * 浏览器完全关闭后`multiple-tabs`将自动从`cookie`中销毁，
 * 再次打开浏览器需要重新登录系统
 * */
export const multipleTabsKey = "multiple-tabs";

/** 获取`token` */
export function getToken(): DataInfo<number> {
  // 此处与`TokenKey`相同，此写法解决初始化时`Cookies`中不存在`TokenKey`报错
  return Cookies.get(TokenKey)
    ? JSON.parse(Cookies.get(TokenKey))
    : storageLocal().getItem(userKey);
}

/**
 * @description 设置`token`以及一些必要信息并采用无感刷新`token`方案
 * 无感刷新：后端返回`accessToken`（访问接口使用的`token`）、`refreshToken`（用于调用刷新`accessToken`的接口时所需的`token`，`refreshToken`的过期时间（比如30天）应大于`accessToken`的过期时间（比如2小时））、`expires`（`accessToken`的过期时间）
 * 将`accessToken`、`expires`、`refreshToken`这三条信息放在key值为authorized-token的cookie里（过期自动销毁）
 * 将`avatar`、`username`、`nickname`、`roles`、`permissions`、`refreshToken`、`expires`这七条信息放在key值为`user-info`的localStorage里（利用`multipleTabsKey`当浏览器完全关闭后自动销毁）
 */
export function setToken(data: DataInfo<Date> | any) {
  console.log("setToken函数接收到的数据:", data);

  let expires = 0;
  const accessToken = data.accessToken || '';
  const refreshToken = data.refreshToken || '';
  const { isRemembered, loginDay } = useUserStoreHook();

  // 如果传入了expires，处理过期时间
  if (data.expires) {
    expires = new Date(data.expires).getTime(); // 如果后端直接设置时间戳，将此处代码改为expires = data.expires
  }

  const cookieString = JSON.stringify({ accessToken, expires, refreshToken });
  console.log("设置到Cookie的token数据:", { accessToken, expires, refreshToken });

  expires > 0
    ? Cookies.set(TokenKey, cookieString, {
      expires: (expires - Date.now()) / 86400000
    })
    : Cookies.set(TokenKey, cookieString);

  Cookies.set(
    multipleTabsKey,
    "true",
    isRemembered
      ? {
        expires: loginDay
      }
      : {}
  );

  // 处理用户信息保存
  const avatar = data.avatar || data.user?.avatar || '';
  const username = data.username || data.user?.username || '';
  const nickname = data.nickname || data.user?.nickname || '';
  const roles = data.roles || [];
  // 保存用户ID
  const id = data.id || data.user?.id || 0;

  console.log("提取的用户基本信息:", { id, avatar, username, nickname, roles });

  // 从登录接口响应中提取权限数据
  let permissions = data.permissions || [];

  // 如果权限数据在user对象中，优先使用该数据
  if (data.user?.permissions && Array.isArray(data.user.permissions)) {
    console.log("从user对象中提取权限数据");
    // 提取按钮权限
    permissions = extractButtonPermissions(data.user.permissions);
  }

  console.log("提取的权限数据:", permissions);

  // 存储用户信息到localStorage和store
  useUserStoreHook().SET_AVATAR(avatar);
  useUserStoreHook().SET_USERNAME(username);
  useUserStoreHook().SET_NICKNAME(nickname);
  useUserStoreHook().SET_ROLES(roles);
  useUserStoreHook().SET_PERMS(permissions);
  // 设置用户ID到store
  useUserStoreHook().SET_ID(id);

  // 如果有菜单数据，也保存到用户存储中
  if (data.user?.permissions && Array.isArray(data.user.permissions)) {
    console.log("设置菜单数据到store");
    // 在存储到store之前先规范化菜单数据
    const normalizedMenus = normalizeMenus(data.user.permissions);
    useUserStoreHook().SET_MENUS(normalizedMenus);

    // 处理菜单生成路由
    const dynamicRoutes = generateRoutes(normalizedMenus);
    // 如果导入了权限存储模块，则处理菜单
    try {
      const permissionStore = require("@/store/modules/permission").usePermissionStoreHook();
      permissionStore.handleWholeMenus(dynamicRoutes);
    } catch (error) {
      console.warn("权限模块加载失败", error);
    }
  }

  const userInfoToStore = {
    id,
    refreshToken,
    expires,
    avatar,
    username,
    nickname,
    roles,
    permissions,
    menus: data.user?.permissions ? normalizeMenus(data.user.permissions) : []
  };

  console.log("即将存储到localStorage的用户信息:", userInfoToStore);
  storageLocal().setItem(userKey, userInfoToStore);
}

/**
 * 规范化菜单数据，确保children不为null
 * @param menus 菜单数据
 * @returns 规范化后的菜单数据
 */
function normalizeMenus(menus: any[]): any[] {
  if (!menus || !Array.isArray(menus)) return [];

  return menus.map(menu => {
    if (!menu) return menu;

    // 创建新对象，避免修改原始对象
    const newMenu = { ...menu };

    // 将null的children替换为空数组
    if (newMenu.children === null) {
      newMenu.children = [];
    } else if (Array.isArray(newMenu.children)) {
      // 递归处理子菜单
      newMenu.children = normalizeMenus(newMenu.children);
    } else {
      // 其他情况(undefined等)设为空数组
      newMenu.children = [];
    }

    return newMenu;
  });
}

/** 删除`token`以及key值为`user-info`的localStorage信息 */
export function removeToken() {
  Cookies.remove(TokenKey);
  Cookies.remove(multipleTabsKey);
  storageLocal().removeItem(userKey);
}

/** 格式化token（jwt格式） */
export const formatToken = (token: string): string => {
  return "Bearer " + token;
};

/** 是否有按钮级别的权限（根据登录接口返回的`permissions`字段进行判断）*/
export const hasPerms = (value: string | Array<string>): boolean => {
  if (!value) return false;
  const allPerms = "*:*:*";
  const { permissions } = useUserStoreHook();
  if (!permissions) return false;
  if (permissions.length === 1 && permissions[0] === allPerms) return true;
  const isAuths = isString(value)
    ? permissions.includes(value)
    : isIncludeAllChildren(value, permissions);
  return isAuths ? true : false;
};

/** 从菜单权限中提取按钮权限 */
function extractButtonPermissions(menus: any[]): string[] {
  if (!menus || !Array.isArray(menus) || menus.length === 0) {
    console.warn("提取按钮权限时传入的菜单数据不是数组或为空");
    return [];
  }

  const buttonPerms: string[] = [];

  // 递归处理菜单树
  const processMenus = (menuItems: any[]) => {
    if (!menuItems || !Array.isArray(menuItems)) return;

    menuItems.forEach(menu => {
      if (!menu) return;

      // 处理当前菜单的按钮权限
      if (menu.meta && menu.meta.auths && Array.isArray(menu.meta.auths)) {
        // 可以格式化为 "moduleName:btnName" 格式
        const modulePrefix = menu.name || 'common';
        menu.meta.auths.forEach(auth => {
          // 可以添加模块前缀，也可以直接使用auth值
          buttonPerms.push(`${modulePrefix}:${auth}`);
          // 也存储原始权限值，确保兼容性
          buttonPerms.push(auth);
        });
      }

      // 处理子菜单 - 确保children不为null
      if (menu.children === null) {
        // children为null，跳过处理
        return;
      } else if (Array.isArray(menu.children) && menu.children.length > 0) {
        processMenus(menu.children);
      }
    });
  };

  processMenus(menus);

  // 添加特殊权限，确保兼容性
  if (buttonPerms.length > 0) {
    buttonPerms.push('*:*:*'); // 全局通配符权限
  }

  return buttonPerms;
}

/** 生成路由 */
function generateRoutes(menus: any[]) {
  if (!menus || !Array.isArray(menus)) {
    console.warn("生成路由时传入的菜单数据不是数组");
    return [];
  }

  const dynamicRoutes = [];

  function formatMenu(menu: any) {
    if (!menu) return null;

    // 构建路由对象
    const route = {
      path: menu.path || "",
      name: menu.name || "",
      component: menu.component,
      meta: {
        ...(menu.meta || {}),
        // 确保meta中包含roles属性，如果后端没有提供，默认为空数组
        roles: menu.meta?.roles || [],
        // 确保显示配置默认为true
        showLink: menu.meta?.showLink !== false
      },
      // 处理children为null的情况
      children: undefined
    };
    // 处理子菜单
    if (menu.children === null) {
      // 如果children为null，则设置为空数组
      route.children = [];
    } else if (Array.isArray(menu.children) && menu.children.length > 0) {
      const formattedChildren = menu.children
        .map(child => formatMenu(child))
        .filter(Boolean); // 过滤掉null结果

      if (formattedChildren.length > 0) {
        route.children = formattedChildren;
      } else {
        route.children = []; // 如果过滤后没有子项，设置为空数组
      }
    }

    return route;
  }

  menus.forEach(menu => {
    if (menu) {
      const formattedMenu = formatMenu(menu);
      if (formattedMenu) {
        dynamicRoutes.push(formattedMenu);
      }
    }
  });

  return dynamicRoutes;
}